Understanding Node Affinity in Kubernetes

Introduction

Node affinity is an advanced feature in Kubernetes that allows you to control where pods are scheduled by setting complex rules for pod placement. While Node Selectors offer a simpler approach, Node Affinity provides more flexibility with expressions like In, NotIn, and Exists, giving you greater control over pod placement based on node labels.

What is Node Affinity?

Node affinity allows you to control which nodes a pod can be scheduled on by defining affinity rules based on node labels. These rules can be mandatory or preferred, depending on the pod's scheduling requirements. This ensures that workloads are deployed on the correct nodes with specific characteristics such as region, instance type, or resource capacities.

Types of Node Affinity

• RequiredDuringSchedulingIgnoredDuringExecution: The pod must be placed on a node that meets the affinity rules during scheduling, but changes to the node's labels during execution are ignored.
• PreferredDuringSchedulingIgnoredDuringExecution: Kubernetes tries to place the pod on a node that matches the affinity rules, but if none are found, it will place the pod on any available node. Like the first type, label changes are ignored once the pod is running.

Example: Using Node Affinity

Step 1: Labeling a Node

Before using node affinity, you need to label the nodes. Here’s how to label a node:

kubectl label nodes node1 size=large

This command adds the label size=large to node1.

Step 2: Creating a Pod with Node Affinity

Let’s create a pod that uses node affinity to ensure it runs only on nodes labeled size=large:

apiVersion: v1
kind: Pod
metadata:
  name: data-processor
spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: size
            operator: In
            values:
            - large
  containers:
    - name: data-processor-container
      image: data-processor:latest

In this example, the pod will only be scheduled on nodes with the label size=large. The In operator allows us to specify a list of values, but in this case, we are only targeting nodes labeled large.

Step 3: Checking Pod Status

To check if the pod is scheduled correctly, run:

kubectl get pods -o wide

Node Affinity Expressions

Node affinity supports a variety of operators that can be used to define scheduling rules:

• In: Matches nodes with the specified label value.
• NotIn: Matches nodes that do not have the specified label value.
• Exists: Matches nodes that have the specified label, regardless of value.
• DoesNotExist: Matches nodes that do not have the specified label.

Example: Multiple Node Labels

apiVersion: v1
kind: Pod
metadata:
  name: data-processor
spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: size
            operator: In
            values:
            - large
            - medium
          - key: region
            operator: In
            values:
            - us-west-1
  containers:
    - name: data-processor-container
      image: data-processor:latest

In this example, the pod will only be scheduled on nodes that have the label size set to either large or medium and the label region set to us-west-1.

Pros and Cons of Node Affinity

Pros

• Offers more flexibility than Node Selectors.
• Supports complex expressions like In, NotIn, and Exists.
• Can be used to prioritize certain nodes without being too restrictive.

Cons

• More complex to configure compared to Node Selectors.
• Cannot dynamically react to changes in node labels (currently).

Real-World Example: Scheduling on Large Compute Nodes

Imagine you have a large data processing application that needs to run on nodes with significant CPU and memory resources. You can use node affinity to ensure that the pods are scheduled on large compute nodes, ensuring they get the resources they need.

Step 1: Labeling the Node

kubectl label nodes compute-node-1 size=large

Step 2: Defining Pod Affinity

apiVersion: v1
kind: Pod
metadata:
  name: big-data-app
spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: size
            operator: In
            values:
            - large
  containers:
    - name: big-data-container
      image: big-data-app:latest

Conclusion

Node affinity gives you more control over where your pods are placed in a Kubernetes cluster. It allows you to define rules for pod scheduling based on node labels and is especially useful in heterogeneous environments with diverse node resources. However, it requires careful configuration, and its flexibility comes with some complexity. As Kubernetes continues to evolve, additional node affinity features may be introduced, such as handling changes during pod execution.